// import { useUserStore } from '@/store/modules/user';
import { getToken } from "@/utils/auth";
import { HttpStatus } from "@/enums/RespEnum";
import { errorCode } from "@/utils/errorCode";
import {
  encryptBase64,
  encryptWithAes,
  generateAesKey,
  decryptWithAes,
  decryptBase64,
} from "@/utils/crypto";
import { encrypt, decrypt } from "@/utils/jsencrypt";
import useUserStore from "@/store/modules/user";

const encryptHeader = "encrypt-key";

// 是否显示重新登录
const isRelogin = { show: false };
const globalHeaders = () => {
  return {
    Authorization: "Bearer " + getToken(),
    clientid: import.meta.env.VITE_APP_CLIENT_ID,
  };
};
const defaultConfig = {
  headers: {
    "Content-Type": "application/json;charset=utf-8",
    clientid: import.meta.env.VITE_APP_CLIENT_ID,
  },
};

const baseInfo = {
  baseURL: import.meta.env.VITE_APP_BASE_API,
  timeout: 50000,
};

// 请求拦截器
const interceptors = (config: {
  headers: {
    [x: string]: any;
    isToken: boolean;
    repeatSubmit: boolean;
    isEncrypt: boolean;
  };
  method: string;
  params: {};
  url: string;
  data: {};
}) => {
  try {
    const isToken = config.headers?.isToken === false;
    // 是否需要防止数据重复提交
    const isRepeatSubmit = config.headers?.repeatSubmit === false;
    // 是否需要加密
    const isEncrypt = config.headers?.isEncrypt === true;

    if (getToken() && !isToken) {
      let token = getToken();
      config.headers["Authorization"] = "Bearer " + token; // 让每个请求携带自定义token 请根据实际情况自行修改
    }
    // get请求映射params参数
    // if (config.method === 'get' && config.params) {
    //   let url = config.url + '?' + tansParams(config.params);
    //   url = url.slice(0, -1);
    //   config.params = {};
    //   config.url = url;
    // }
    console.log("config=======>", config);
    if (
      !isRepeatSubmit &&
      (config.method === "post" || config.method === "put")
    ) {
      const requestObj = {
        url: config.url,
        data:
          typeof config.data === "object"
            ? JSON.stringify(config.data)
            : config.data,
        time: new Date().getTime(),
      };
      const sessionObj = uni.getStorageSync("sessionObj") || null;
      if (
        sessionObj === undefined ||
        sessionObj === null ||
        sessionObj === ""
      ) {
        uni.setStorageSync("sessionObj", requestObj);
      } else {
        const s_url = sessionObj.url; // 请求地址
        const s_data = sessionObj.data; // 请求数据
        const s_time = sessionObj.time; // 请求时间
        const interval = 500; // 间隔时间(ms)，小于此时间视为重复提交
        if (
          s_data === requestObj.data &&
          requestObj.time - s_time < interval &&
          s_url === requestObj.url
        ) {
          const message = "数据正在处理，请勿重复提交";
          console.warn(`[${s_url}]: ` + message);
          //return Promise.reject(new Error(message));
        } else {
          uni.setStorageSync("sessionObj", requestObj);
          //cache.session.setJSON('sessionObj', requestObj);
        }
      }
    }
    console.log("isRepeatSubmit=======>", import.meta.env.VITE_APP_ENCRYPT);

    if (import.meta.env.VITE_APP_ENCRYPT === "true") {
      // 当开启参数加密
      if (isEncrypt && (config.method === "post" || config.method === "put")) {
        // 生成一个 AES 密钥
        const aesKey = generateAesKey();
        config.headers[encryptHeader] = encrypt(encryptBase64(aesKey));
        config.data =
          typeof config.data === "object"
            ? encryptWithAes(JSON.stringify(config.data), aesKey)
            : encryptWithAes(config.data, aesKey);
      }
    }
    // FormData数据去请求头Content-Type
    if (config.data instanceof FormData) {
      delete config.headers["Content-Type"];
    }
    console.log("config=======>", config);
    return config;
  } catch (e) {
    console.log("报错", e);
    return Promise.reject(e);
  }
};

// // 创建 axios 实例

// // 导出一个函数

export function request(config: any): Promise<void> {
  let baseConfig = interceptors({ ...defaultConfig, ...config });
  console.log("baseConfig===>1", config.data);
  // console.log('data',baseConfig);
  return new Promise((resolve, reject) => {
    let { method, url, data, headers } = { ...baseConfig };
    uni.request({
      method,
      url: import.meta.env.VITE_APP_BASE_API + url, //仅为示例，并非真实接口地址。
      data,
      header: headers,
      firstIpv4: true,
      timeout: 30000,
      success: (res) => {
        console.log("request success", res);
        if (import.meta.env.VITE_APP_ENCRYPT === "true") {
          // 加密后的 AES 秘钥
          const keyStr = res.header[encryptHeader];
          // 加密
          if (keyStr != null && keyStr != "") {
            const data = res.data;
            // 请求体 AES 解密
            const base64Str = decrypt(keyStr);
            // base64 解码 得到请求头的 AES 秘钥
            const aesKey = decryptBase64(base64Str.toString());
            // aesKey 解码 data
            const decryptData = decryptWithAes(data, aesKey);
            // 将结果 (得到的是 JSON 字符串) 转为 JSON
            res.data = JSON.parse(decryptData);
          }
          console.log("request success===解密", res.data);
        }
        // 未设置状态码则默认成功状态
        const code = res.data.code || HttpStatus.SUCCESS;
        // 获取错误信息
        const msg = errorCode[code] || res.data.msg || errorCode["default"];
        // 二进制数据则直接返回
        // if (res.request.responseType === 'blob' || res.request.responseType === 'arraybuffer') {
        //   return res.data;
        // }
        if (code === 401) {
          // prettier-ignore
          if (!isRelogin.show) {
								isRelogin.show = true;
								uni.showModal({
									title: '提示',
									content: '登录已过期，请点击重新登录',
									showCancel: false,
									success: (ret) => {
										if (ret.confirm) {
											isRelogin.show = false;
											useUserStore().logout().then(() => {
												location.href = import.meta.env.VITE_APP_CONTEXT_PATH + 'index';
											});
										} else {
											 isRelogin.show = false;
										}
									}
								})
							  }
          return Promise.reject("无效的会话，或者会话已过期，请重新登录。");
        } else if (code === HttpStatus.SERVER_ERROR) {
          // ElMessage({ message: msg, type: 'error' });
          return Promise.reject(new Error(msg));
        } else if (code === HttpStatus.WARN) {
          //ElMessage({ message: msg, type: 'warning' });
          return Promise.reject(new Error(msg));
        } else if (code !== HttpStatus.SUCCESS) {
          //ElNotification.error({ title: msg });
          return Promise.reject("error");
        } else {
          console.log("request success===返回", res.data);
          resolve(res.data);
        }
      },
      fail: (err) => {
        // 接口调用失败的回调函数
        console.log("appRequest==>err", err);
        uni.showToast({
          title: err.errMsg,
          icon: "none",
        });
        //reject(err)
        // let { message } = error;
        // if (message == 'Network Error') {
        //   message = '后端接口连接异常';
        // } else if (message.includes('timeout')) {
        //   message = '系统接口请求超时';
        // } else if (message.includes('Request failed with status code')) {
        //   message = '系统接口' + message.substr(message.length - 3) + '异常';
        // }
        // uni.showToast({
        // 			title: message,
        // 			icon: "error"
        // })
        return Promise.reject(err);
      },
    });
  });
}
